Como usar la clase de Error Handling en angular para realizar la gestion de excepciones

Primero tenemos que indicar en el archivo app.module.ts la clase que usaremos para el ErrorHandler, lo hacemos en la seccion de provider:[] de la siguiente manera:

providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]

Donde MyErrorHandler será el nombre de la clase que usaremos para manejar los errores.

A continuación creamos un archivo my-error-handler.ts donde definiremos nuestra clase MyErrorHandler:

import { ErrorHandler } from "@angular/core";

export class MyErrorHandler implements ErrorHandler {
    handleError(error: any): void {
        console.log("Ha ocurrido un error");
    }

}

La clase MyErrorHandler implementa ErrorHandler cuya interfaz nos obliga a definir la funcion handleError().

Con esta configuración la clase MyErrorHandler se encargará de manejar todas las excepciones que lance la aplicación, podríamos testearla con el siguiente código dentro de un componente:

throw new Error("Error de prueba");

Podemos hacer que la clase maneje distintos tipos de excepciones, para ello vamos a definir dos excepciones distintas:

ExcepcionUno:

export class ExcepcionUno extends Error {
    constructor(message: string) {
        super(message);
    }
}

ExcepcionDos:

export class ExcepcionDos extends Error {
    constructor(message: string) {
        super(message);
    }
}

Y ahora en nuestra clase MyErrorHandler pondríamos el siguiente código:

import { ErrorHandler } from "@angular/core";
import { ExcepcionDos } from "./excepcion-dos";
import { ExcepcionUno } from "./excepcion-uno";

export class MyErrorHandler implements ErrorHandler {
    handleError(error: any): void {

        if(error instanceof ExcepcionUno){
            console.log("Se ha lanzado ExcepcionUno");
        }
        else if(error instanceof ExcepcionDos){
            console.log("Se ha lanzado ExcepcionDos");
        }
    }

}

Ahora de esta manera podemos gestionar varios tipos de excepciones y hacer una cosa u otra en función de la excepción.

Este nuevo caso prodríamos probarlo lanzando los dos tipos de excepciones usando:

throw new ExcepcionUno("Error uno"); throw new ExcepcionDos("Error dos");

NOTA: esto todavía lo tengo bajo investigación

Cuando se lanza una excepción dentro de una promesa la excepción viene envuelta por otro objeto, lo que podemos hacer en estos casos es un unwrap de la excepción para poder manejarla:

import { ErrorHandler } from "@angular/core";
import { ExcepcionDos } from "./excepcion-dos";
import { ExcepcionUno } from "./excepcion-uno";

export class MyErrorHandler implements ErrorHandler {
    handleError(wrapperError: any): void {
        const error = wrapperError.rejection ? wrapperError.rejection : wrapperError;

        if(error instanceof ExcepcionUno){
            console.log("Se ha lanzado ExcepcionUno");
        }
        else if(error instanceof ExcepcionDos){
            console.log("Se ha lanzado ExcepcionDos");
        }
    }

}

En la promesa podemos capturar el error interno que se lanze y lanzar nuestra propia excepción:

.catch(() => {throw new ExcepcionUno("Error uno")})

Error Handling | Angular